Groovy JDK

java.lang
Class Object[]

Method Summary
boolean asBoolean()
Coerce an Object array to a boolean value.
Object asType(Class clazz)
Converts the given array to either a List, Set, or SortedSet.
Map collectEntries(Map collector, Closure transform)
Iterates through this array transforming each item using the transform closure and returning a map of the resulting transformed entries.
Map collectEntries(Map collector)
A variant of collectEntries using the identity closure as the transform.
Map collectEntries(Closure transform)
Iterates through this array transforming each item using the transform closure and returning a map of the resulting transformed entries.
Map collectEntries()
A variant of collectEntries using the identity closure as the transform.
List collectMany(Closure projection)
Projects each item from a source array to a collection and concatenates (flattens) the resulting collections into a single list.
boolean contains(Object value)
Checks whether the array contains the given value.
Number count(Object value)
Counts the number of occurrences of the given value inside this array.
Number count(Closure closure)
Counts the number of occurrences which satisfy the given closure from inside this array.
Map countBy(Closure closure)
Sorts all array members into groups determined by the supplied mapping closure and counts the group size.
Object[] drop(int num)
Drops the given number of elements from the head of this array if they are available.
Object[] dropWhile(Closure condition)
Create a suffix of the given array by dropping as many elements as possible from the front of the original array such that calling the given closure condition evaluates to true when passed each of the dropped elements.
boolean equals(List right)
Determines if the contents of this array are equal to the contents of the given list, in the same order.
Object find(Closure condition)
Finds the first element in the array that matches the given closure condition.
Collection findAll(Closure condition)
Finds all elements of the array matching the given Closure condition.
Collection findAll()
Finds the elements of the array matching the IDENTITY Closure (i.e. matching Groovy truth).
Object first()
Returns the first item from the array.
Collection flatten()
Flatten an array.
List getAt(Collection indices)
Select a List of items from an Object array using a Collection to identify the indices to be selected.
List getAt(Range range)
Support the range subscript operator for an Array
List getAt(IntRange range)
List getAt(EmptyRange range)
List getAt(ObjectRange range)
Collection grep(Object filter)
Iterates over the array of items and returns a collection of items that match the given filter - calling the Object#isCase method used by switch statements.
Collection grep()
Iterates over the array returning each element that matches using the IDENTITY Closure as a filter - effectively returning all elements which satisfy Groovy truth.
Object head()
Returns the first item from the Object array.
Object inject(Closure closure)
Iterates through the given array as with inject(Object[],initialValue,closure), but using the first element of the array as the initialValue, and then iterating the remaining elements of the array.
Object inject(Object initialValue, Closure closure)
Iterates through the given array, passing in the initial value to the closure along with the first item.
Iterator iterator()
Attempts to create an Iterator for the given object by first converting it to a Collection.
String join(String separator)
Concatenates the toString() representation of each items in this array, with the given String as a separator between each item.
Object last()
Returns the last item from the array.
Object max()
Adds max() method to Object arrays.
Object max(Closure closure)
Selects the maximum value found from the Object array using the closure to determine the correct ordering.
Object max(Comparator comparator)
Selects the maximum value found from the Object array using the given comparator.
Object min()
Adds min() method to Object arrays.
Object min(Comparator comparator)
Selects the minimum value found from the Object array using the given comparator.
Object min(Closure closure)
Selects the minimum value found from the Object array using the closure to determine the correct ordering.
Object[] minus(Iterable removeMe)
Create an array composed of the elements of the first array minus the elements of the given Iterable.
Object[] minus(Object[] removeMe)
Create an array composed of the elements of the first array minus the elements of the given array.
Object[] minus(Object removeMe)
Create a new object array composed of the elements of the first array minus the element to remove.
Object[] plus(Object[] right)
Create an array as a union of two arrays.
Object[] plus(Object right)
Create an array containing elements from an original array plus an additional appended element.
Object[] plus(Collection right)
Create an array containing elements from an original array plus those from a Collection.
Object[] plus(Iterable right)
Create an array containing elements from an original array plus those from an Iterable.
Object[] reverse()
Creates a new array containing items which are the same as this array but in reverse order.
Object[] reverse(boolean mutate)
Reverse the items in an array.
Object[] reverseEach(Closure closure)
Iterate over each element of the array in the reverse order.
int size()
Provide the standard Groovy size() method for an array.
Object[] sort()
Modifies this array so that its elements are in sorted order.
Object[] sort(boolean mutate)
Sorts the given array into sorted order.
Object[] sort(Comparator comparator)
Sorts the given array into sorted order using the given comparator.
Object[] sort(boolean mutate, Comparator comparator)
Modifies this array so that its elements are in sorted order as determined by the given comparator.
Object[] sort(Closure closure)
Sorts the elements from this array into a newly created array using the Closure to determine the correct ordering.
Object[] sort(boolean mutate, Closure closure)
Modifies this array so that its elements are in sorted order using the Closure to determine the correct ordering.
Object sum()
Sums the items in an array.
Object sum(Object initialValue)
Sums the items in an array, adding the result to some initial value.
Object sum(Closure closure)
Sums the result of apply a closure to each item of an array.
Object sum(Object initialValue, Closure closure)
Sums the result of applying a closure to each item of an array to some initial value.
Object[] tail()
Returns the items from the Object array excluding the first item.
Object[] take(int num)
Returns the first num elements from the head of this array.
Object[] takeWhile(Closure condition)
Returns the longest prefix of this array where each element passed to the given closure evaluates to true.
String toArrayString()
Returns the string representation of the given array.
List toList()
Allows conversion of arrays into a mutable List.
SpreadMap toSpreadMap()
Creates a spreadable map from this array.
String toString()
Returns the string representation of this array's contents.
 
Method Detail

asBoolean

public boolean asBoolean()
 
Coerce an Object array to a boolean value. An Object array is false if the array is of length 0. and to true otherwise
Returns:
the boolean value
Since:
1.7.0

asType

public Object asType(Class clazz)
 
Converts the given array to either a List, Set, or SortedSet. If the given class is something else, the call is deferred to {link #asType(Object,Class)}.
Parameters:
clazz - the desired class.
Returns:
the object resulting from this type conversion
Since:
1.5.1
See:
Object#asType.

collectEntries

public Map collectEntries(Map collector, Closure transform)
 
Iterates through this array transforming each item using the transform closure and returning a map of the resulting transformed entries.
def letters = "abc"
def nums = [0, 1, 2] as Integer[]
// collect letters with index
assert nums.collectEntries( [:] ) { index -> [index, letters[index]] } == [0:'a', 1:'b', 2:'c']
assert nums.collectEntries( [4:'d'] ) { index ->
    [(index+1): letters[index]] } == [1:'a', 2:'b', 3:'c', 4:'d']
Parameters:
collector - the Map into which the transformed entries are put.
transform - the closure used for transforming, which has an item from self as the parameter and should return a Map.Entry, a Map or a two-element list containing the resulting key and value.
Returns:
the collector with all transformed values added to it
Since:
1.7.9
See:
Map#collect(Collection, Closure).

collectEntries

public Map collectEntries(Map collector)
 
A variant of collectEntries using the identity closure as the transform.
Parameters:
collector - the Map into which the transformed entries are put.
Returns:
the collector with all transformed values added to it
Since:
1.8.5
See:
Object[]#collectEntries(Map, Closure).

collectEntries

public Map collectEntries(Closure transform)
 
Iterates through this array transforming each item using the transform closure and returning a map of the resulting transformed entries.
def letters = "abc"
def nums = [0, 1, 2] as Integer[]
// collect letters with index using list style
assert nums.collectEntries { index -> [index, letters[index]] } == [0:'a', 1:'b', 2:'c']
// collect letters with index using map style
assert nums.collectEntries { index -> [(index): letters[index]] } == [0:'a', 1:'b', 2:'c']
Parameters:
transform - the closure used for transforming, which has an item from self as the parameter and should return a Map.Entry, a Map or a two-element list containing the resulting key and value.
Returns:
a Map of the transformed entries
Since:
1.7.9
See:
Collection#collectEntries(Map, Closure).

collectEntries

public Map collectEntries()
 
A variant of collectEntries using the identity closure as the transform.
Returns:
the collector with all transformed values added to it
Since:
1.8.5
See:
Object[]#collectEntries(Closure).

collectMany

public List collectMany(Closure projection)
 
Projects each item from a source array to a collection and concatenates (flattens) the resulting collections into a single list.

def nums = [1, 2, 3, 4, 5, 6] as Object[]
def squaresAndCubesOfEvens = nums.collectMany{ it % 2 ? [] : [it**2, it**3] }
assert squaresAndCubesOfEvens == [4, 8, 16, 64, 36, 216]
Parameters:
projection - a projecting Closure returning a collection of items.
Returns:
a list created from the projected collections concatenated (flattened) together
Since:
1.8.1
See:
Object[]#sum.

contains

public boolean contains(Object value)
 
Checks whether the array contains the given value.
Parameters:
value - the value being searched for.
Returns:
true if the array contains the value
Since:
1.8.6

count

public Number count(Object value)
 
Counts the number of occurrences of the given value inside this array. Comparison is done using Groovy's == operator (using compareTo(value) == 0 or equals(value) ).
Parameters:
value - the value being searched for.
Returns:
the number of occurrences
Since:
1.6.4

count

public Number count(Closure closure)
 
Counts the number of occurrences which satisfy the given closure from inside this array.
Parameters:
closure - a closure condition.
Returns:
the number of occurrences
Since:
1.8.0

countBy

public Map countBy(Closure closure)
 
Sorts all array members into groups determined by the supplied mapping closure and counts the group size. The closure should return the key that each item should be grouped by. The returned Map will have an entry for each distinct key returned from the closure, with each value being the frequency of items occurring for that group.

Example usage:

assert ([1,2,2,2,3] as Object[]).countBy{ it % 2 } == [1:2, 0:3]
Parameters:
closure - a closure mapping items to the frequency keys.
Returns:
a new Map grouped by keys with frequency counts
Since:
1.8.0
See:
Collection#countBy(Closure).

drop

public Object[] drop(int num)
 
Drops the given number of elements from the head of this array if they are available.
String[] strings = [ 'a', 'b', 'c' ]
assert strings.drop( 0 ) == [ 'a', 'b', 'c' ] as String[]
assert strings.drop( 2 ) == [ 'c' ] as String[]
assert strings.drop( 5 ) == [] as String[]
Parameters:
num - the number of elements to drop from this array.
Returns:
an array consisting of all elements of this array except the first num ones, or else the empty array, if this array has less than num elements.
Since:
1.8.1

dropWhile

public Object[] dropWhile(Closure condition)
 
Create a suffix of the given array by dropping as many elements as possible from the front of the original array such that calling the given closure condition evaluates to true when passed each of the dropped elements.
def nums = [ 1, 3, 2 ] as Integer[]
assert nums.dropWhile{ it <= 3 } == [ ] as Integer[]
assert nums.dropWhile{ it < 3 } == [ 3, 2 ] as Integer[]
assert nums.dropWhile{ it != 2 } == [ 2 ] as Integer[]
assert nums.dropWhile{ it == 0 } == [ 1, 3, 2 ] as Integer[]
Parameters:
condition - the closure that must evaluate to true to continue dropping elements.
Returns:
the shortest suffix of the given array such that the given closure condition evaluates to true for each element dropped from the front of the array
Since:
1.8.7

equals

public boolean equals(List right)
 
Determines if the contents of this array are equal to the contents of the given list, in the same order. This returns false if either collection is null.
Parameters:
right - the List being compared.
Returns:
true if the contents of both collections are equal
Since:
1.5.0

find

public Object find(Closure condition)
 
Finds the first element in the array that matches the given closure condition. Example:
def list = [1,2,3] as Integer[]
assert 2 == list.find { it > 1 }
assert null == list.find { it > 5 }
Parameters:
condition - a closure condition.
Returns:
the first element from the array that matches the condition or null if no element matches
Since:
2.0

findAll

public Collection findAll(Closure condition)
 
Finds all elements of the array matching the given Closure condition.
def items = [1,2,3,4] as Integer[]
assert [2,4] == items.findAll { it % 2 == 0 }
Parameters:
condition - a closure condition.
Returns:
a list of matching values
Since:
2.0

findAll

public Collection findAll()
 
Finds the elements of the array matching the IDENTITY Closure (i.e. matching Groovy truth).

Example:

def items = [1, 2, 0, false, true, '', 'foo', [], [4, 5], null] as Object[]
assert items.findAll() == [1, 2, true, 'foo', [4, 5]]
Returns:
a collection of the elements found
Since:
2.0
See:
Closure#IDENTITY.

first

public Object first()
 
Returns the first item from the array.
def array = [3, 4, 2].toArray()
assert array.first() == 3
Returns:
the first item from the array
Since:
1.7.3

flatten

public Collection flatten()
 
Flatten an array. This array and any nested arrays or collections have their contents (recursively) added to the new collection.
Returns:
a flattened Collection
Since:
1.6.0

getAt

public List getAt(Collection indices)
 
Select a List of items from an Object array using a Collection to identify the indices to be selected.
Parameters:
indices - a Collection of indices.
Returns:
a new list of the values at the given indices
Since:
1.0

getAt

public List getAt(Range range)
 
Support the range subscript operator for an Array
Parameters:
range - a Range.
Returns:
a range of a list from the range's from index up to but not including the range's to value
Since:
1.0

getAt

public List getAt(IntRange range)
 
Parameters:
range - an IntRange.
Returns:
a range of a list from the range's from index up to but not including the range's to value
Since:
1.0

getAt

public List getAt(EmptyRange range)
 
Parameters:
range - an EmptyRange.
Returns:
an empty Range
Since:
1.5.0

getAt

public List getAt(ObjectRange range)
 
Parameters:
range - an ObjectRange.
Returns:
a range of a list from the range's from index up to but not including the range's to value
Since:
1.0

grep

public Collection grep(Object filter)
 
Iterates over the array of items and returns a collection of items that match the given filter - calling the Object#isCase method used by switch statements. This method can be used with different kinds of filters like regular expressions, classes, ranges etc. Example:
def list = ['a', 'b', 'aa', 'bc', 3, 4.5] as Object[]
assert list.grep( ~/a+/ )  == ['a', 'aa']
assert list.grep( ~/../ )  == ['aa', 'bc']
assert list.grep( Number ) == [ 3, 4.5 ]
assert list.grep{ it.toString().size() == 1 } == [ 'a', 'b', 3 ]
Parameters:
filter - the filter to perform on each element of the array (using the Object#isCase method).
Returns:
a collection of objects which match the filter
Since:
2.0

grep

public Collection grep()
 
Iterates over the array returning each element that matches using the IDENTITY Closure as a filter - effectively returning all elements which satisfy Groovy truth.

Example:

def items = [1, 2, 0, false, true, '', 'foo', [], [4, 5], null] as Object[]
assert items.grep() == [1, 2, true, 'foo', [4, 5]]
Returns:
a collection of elements which satisfy Groovy truth
Since:
2.0
See:
Closure#IDENTITY.

head

public Object head()
 
Returns the first item from the Object array.
def array = [3, 4, 2].toArray()
assert array.head() == 3
Returns:
the first item from the Object array
Since:
1.7.3

inject

public Object inject(Closure closure)
 
Iterates through the given array as with inject(Object[],initialValue,closure), but using the first element of the array as the initialValue, and then iterating the remaining elements of the array.
Parameters:
closure - a closure.
Returns:
the result of the last closure call
Since:
1.8.7
See:
Object[]#inject(Object, Closure).

inject

public Object inject(Object initialValue, Closure closure)
 
Iterates through the given array, passing in the initial value to the closure along with the first item. The result is passed back (injected) into the closure along with the second item. The new result is injected back into the closure along with the third item and so on until all elements of the array have been used. Also known as foldLeft in functional parlance.
Parameters:
initialValue - some initial value.
closure - a closure.
Returns:
the result of the last closure call
Since:
1.5.0
See:
Collection#inject(Object, Closure).

iterator

public Iterator iterator()
 
Attempts to create an Iterator for the given object by first converting it to a Collection.
Returns:
an Iterator for the given Array.
Since:
1.6.4
See:
DefaultTypeTransformation#asCollection.

join

public String join(String separator)
 
Concatenates the toString() representation of each items in this array, with the given String as a separator between each item.
Parameters:
separator - a String separator.
Returns:
the joined String
Since:
1.0

last

public Object last()
 
Returns the last item from the array.
def array = [3, 4, 2].toArray()
assert array.last() == 2
Returns:
the last item from the array
Since:
1.7.3

max

public Object max()
 
Adds max() method to Object arrays.
Returns:
the maximum value
Since:
1.5.5
See:
Collection#max.

max

public Object max(Closure closure)
 
Selects the maximum value found from the Object array using the closure to determine the correct ordering. If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
Parameters:
closure - a Closure used to determine the correct ordering.
Returns:
the maximum value
Since:
1.5.5
See:
Collection#max.

max

public Object max(Comparator comparator)
 
Selects the maximum value found from the Object array using the given comparator.
Parameters:
comparator - a Comparator.
Returns:
the maximum value
Since:
1.5.5

min

public Object min()
 
Adds min() method to Object arrays.
Returns:
the minimum value
Since:
1.5.5
See:
Collection#min.

min

public Object min(Comparator comparator)
 
Selects the minimum value found from the Object array using the given comparator.
Parameters:
comparator - a Comparator.
Returns:
the minimum value
Since:
1.5.5
See:
Collection#min.

min

public Object min(Closure closure)
 
Selects the minimum value found from the Object array using the closure to determine the correct ordering. If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
Parameters:
closure - a Closure used to determine the correct ordering.
Returns:
the minimum value
Since:
1.5.5
See:
Collection#min.

minus

public Object[] minus(Iterable removeMe)
 
Create an array composed of the elements of the first array minus the elements of the given Iterable.
Parameters:
removeMe - a Collection of elements to remove.
Returns:
an array with the supplied elements removed
Since:
1.5.5

minus

public Object[] minus(Object[] removeMe)
 
Create an array composed of the elements of the first array minus the elements of the given array.
Parameters:
removeMe - an array of elements to remove.
Returns:
an array with the supplied elements removed
Since:
1.5.5

minus

public Object[] minus(Object removeMe)
 
Create a new object array composed of the elements of the first array minus the element to remove.
Parameters:
removeMe - an element to remove from the array.
Returns:
a new array with the operand removed
Since:
1.5.5

plus

public Object[] plus(Object[] right)
 
Create an array as a union of two arrays.
Integer[] a = [1, 2, 3]
Integer[] b = [4, 5, 6]
assert a + b == [1, 2, 3, 4, 5, 6] as Integer[]
Parameters:
right - the right Array.
Returns:
A new array containing right appended to left.
Since:
1.8.7

plus

public Object[] plus(Object right)
 
Create an array containing elements from an original array plus an additional appended element.
Integer[] a = [1, 2, 3]
Integer[] result = a + 4
assert result == [1, 2, 3, 4] as Integer[]
Parameters:
right - the value to append.
Returns:
A new array containing left with right appended to it.
Since:
1.8.7

plus

public Object[] plus(Collection right)
 
Create an array containing elements from an original array plus those from a Collection.
Integer[] a = [1, 2, 3]
def additions = [7, 8]
assert a + additions == [1, 2, 3, 7, 8] as Integer[]
Parameters:
right - a Collection to be appended.
Returns:
A new array containing left with right appended to it.
Since:
1.8.7

plus

public Object[] plus(Iterable right)
 
Create an array containing elements from an original array plus those from an Iterable.
class AbcIterable implements Iterable {
    Iterator iterator() { "abc".iterator() }
}
String[] letters = ['x', 'y', 'z']
def result = letters + new AbcIterable()
assert result == ['x', 'y', 'z', 'a', 'b', 'c'] as String[]
assert result.class.array
Parameters:
right - an Iterable to be appended.
Returns:
A new array containing elements from left with those from right appended.
Since:
1.8.7

reverse

public Object[] reverse()
 
Creates a new array containing items which are the same as this array but in reverse order.
Returns:
an array containing the reversed items
Since:
1.5.5
See:
Object[]#reverse(boolean).

reverse

public Object[] reverse(boolean mutate)
 
Reverse the items in an array. If mutate is true, the original array is modified in place and returned. Otherwise, a new array containing the reversed items is produced.
Parameters:
mutate - true if the array itself should be reversed in place and returned, false if a new array should be created.
Returns:
an array containing the reversed items
Since:
1.8.1

reverseEach

public Object[] reverseEach(Closure closure)
 
Iterate over each element of the array in the reverse order.
Parameters:
closure - a closure to which each item is passed.
Returns:
the original array
Since:
1.5.2

size

public int size()
 
Provide the standard Groovy size() method for an array.
Returns:
the size (length) of the Array
Since:
1.0

sort

public Object[] sort()
 
Modifies this array so that its elements are in sorted order. The array items are assumed to be comparable.
Returns:
the sorted array
Since:
1.5.5

sort

public Object[] sort(boolean mutate)
 
Sorts the given array into sorted order. The array items are assumed to be comparable. If mutate is true, the array is sorted in place and returned. Otherwise, a new sorted array is returned and the original array remains unchanged.
def orig = ["hello","hi","Hey"] as String[]
def sorted = orig.sort(false)
assert orig == ["hello","hi","Hey"] as String[]
assert sorted == ["Hey","hello","hi"] as String[]
orig.sort(true)
assert orig == ["Hey","hello","hi"] as String[]
Parameters:
mutate - false will always cause a new array to be created, true will mutate the array in place.
Returns:
the sorted array
Since:
1.8.1

sort

public Object[] sort(Comparator comparator)
 
Sorts the given array into sorted order using the given comparator.
Parameters:
comparator - a Comparator used for the comparison.
Returns:
the sorted array
Since:
1.5.5

sort

public Object[] sort(boolean mutate, Comparator comparator)
 
Modifies this array so that its elements are in sorted order as determined by the given comparator. If mutate is true, the array is sorted in place and returned. Otherwise, a new sorted array is returned and the original array remains unchanged.
def orig = ["hello","hi","Hey"] as String[]
def sorted = orig.sort(false, String.CASE_INSENSITIVE_ORDER)
assert orig == ["hello","hi","Hey"] as String[]
assert sorted == ["hello","Hey","hi"] as String[]
orig.sort(true, String.CASE_INSENSITIVE_ORDER)
assert orig == ["hello","Hey","hi"] as String[]
Parameters:
mutate - false will always cause a new array to be created, true will mutate arrays in place.
comparator - a Comparator used for the comparison.
Returns:
a sorted array
Since:
1.8.1

sort

public Object[] sort(Closure closure)
 
Sorts the elements from this array into a newly created array using the Closure to determine the correct ordering. If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
Parameters:
closure - a Closure used to determine the correct ordering.
Returns:
the sorted array
Since:
1.5.5

sort

public Object[] sort(boolean mutate, Closure closure)
 
Modifies this array so that its elements are in sorted order using the Closure to determine the correct ordering. If mutate is false, a new array is returned and the original array remains unchanged. Otherwise, the original array is sorted in place and returned. If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
def orig = ["hello","hi","Hey"] as String[]
def sorted = orig.sort(false) { it.size() }
assert orig == ["hello","hi","Hey"] as String[]
assert sorted == ["hi","Hey","hello"] as String[]
orig.sort(true) { it.size() }
assert orig == ["hi","Hey","hello"] as String[]
Parameters:
mutate - false will always cause a new array to be created, true will mutate arrays in place.
closure - a Closure used to determine the correct ordering.
Returns:
the sorted array
Since:
1.8.1

sum

public Object sum()
 
Sums the items in an array. This is equivalent to invoking the "plus" method on all items in the array.
Returns:
The sum of all of the items
Since:
1.7.1
See:
Collection#sum.

sum

public Object sum(Object initialValue)
 
Sums the items in an array, adding the result to some initial value.
Parameters:
initialValue - the items in the array will be summed to this initial value.
Returns:
The sum of all of the items.
Since:
1.7.1

sum

public Object sum(Closure closure)
 
Sums the result of apply a closure to each item of an array. array.sum(closure) is equivalent to: array.collect(closure).sum().
Parameters:
closure - a single parameter closure that returns a numeric value..
Returns:
The sum of the values returned by applying the closure to each item of the array.
Since:
1.7.1

sum

public Object sum(Object initialValue, Closure closure)
 
Sums the result of applying a closure to each item of an array to some initial value. array.sum(initVal, closure) is equivalent to: array.collect(closure).sum(initVal).
Parameters:
closure - a single parameter closure that returns a numeric value..
initialValue - the closure results will be summed to this initial value.
Returns:
The sum of the values returned by applying the closure to each item of the array.
Since:
1.7.1

tail

public Object[] tail()
 
Returns the items from the Object array excluding the first item.
    String[] strings = ["a", "b", "c"]
    def result = strings.tail()
    assert strings.class.componentType == String
Returns:
an Object array without its first element
Since:
1.7.3

take

public Object[] take(int num)
 
Returns the first num elements from the head of this array.
String[] strings = [ 'a', 'b', 'c' ]
assert strings.take( 0 ) == [] as String[]
assert strings.take( 2 ) == [ 'a', 'b' ] as String[]
assert strings.take( 5 ) == [ 'a', 'b', 'c' ] as String[]
Parameters:
num - the number of elements to take from this array.
Returns:
an array consisting of the first num elements of this array, or else the whole array if it has less then num elements.
Since:
1.8.1

takeWhile

public Object[] takeWhile(Closure condition)
 
Returns the longest prefix of this array where each element passed to the given closure evaluates to true.
def nums = [ 1, 3, 2 ] as Integer[]
assert nums.takeWhile{ it < 1 } == [] as Integer[]
assert nums.takeWhile{ it < 3 } == [ 1 ] as Integer[]
assert nums.takeWhile{ it < 4 } == [ 1, 3, 2 ] as Integer[]
Parameters:
condition - the closure that must evaluate to true to continue taking elements.
Returns:
a prefix of the given array where each element passed to the given closure evaluates to true
Since:
1.8.7

toArrayString

public String toArrayString()
 
Returns the string representation of the given array. The string displays the contents of the array, similar to an array literal, i.e. {1, 2, "a"}.
Returns:
the string representation
Since:
1.0

toList

public List toList()
 
Allows conversion of arrays into a mutable List.
Returns:
the array as a List
Since:
1.0

toSpreadMap

public SpreadMap toSpreadMap()
 
Creates a spreadable map from this array.

Returns:
a newly created SpreadMap
Since:
1.0
See:
SpreadMap#SpreadMap.
Map#toSpreadMap.

toString

public String toString()
 
Returns the string representation of this array's contents.
Returns:
the string representation
Since:
1.0
See:
Object[]#toArrayString.

Groovy JDK